/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * File Name          : LWIP.c
 * Description        : This file provides initialization code for LWIP
 *                      middleWare.
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2025 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "lwip.h"

#include "lwip/init.h"
#include "lwip/netif.h"
#if defined(__CC_ARM) /* MDK ARM Compiler */
#include "lwip/sio.h"
#endif /* MDK ARM Compiler */
#include "cfg.h"
#include "ethernetif.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */
/* Private function prototypes -----------------------------------------------*/
/* ETH Variables initialization ----------------------------------------------*/
void Error_Handler(void);

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */
/* Semaphore to signal Ethernet Link state update */
osSemaphoreId Netif_LinkSemaphore = NULL;
/* Ethernet link thread Argument */
struct link_str link_arg;

/* Variables Initialization */
struct netif gnetif;
ip4_addr_t ipaddr;
ip4_addr_t netmask;
ip4_addr_t gw;
uint8_t IP_ADDRESS[4];
uint8_t NETMASK_ADDRESS[4];
uint8_t GATEWAY_ADDRESS[4];

/* USER CODE BEGIN 2 */
void reset_ip_and_restart_tcp(void) {
    printf("Resetting IP address...\r\n");

    IP_ADDRESS[0] = cfg.ip[0];
    IP_ADDRESS[1] = cfg.ip[1];
    IP_ADDRESS[2] = cfg.ip[2];
    IP_ADDRESS[3] = cfg.ip[3];
    NETMASK_ADDRESS[0] = 255;
    NETMASK_ADDRESS[1] = 255;
    NETMASK_ADDRESS[2] = 255;
    NETMASK_ADDRESS[3] = 0;
    GATEWAY_ADDRESS[0] = cfg.ip[0];
    GATEWAY_ADDRESS[1] = cfg.ip[1];
    GATEWAY_ADDRESS[2] = cfg.ip[2];
    GATEWAY_ADDRESS[3] = 1;

    IP4_ADDR(&ipaddr, IP_ADDRESS[0], IP_ADDRESS[1], IP_ADDRESS[2],
             IP_ADDRESS[3]);
    IP4_ADDR(&netmask, NETMASK_ADDRESS[0], NETMASK_ADDRESS[1],
             NETMASK_ADDRESS[2], NETMASK_ADDRESS[3]);
    IP4_ADDR(&gw, GATEWAY_ADDRESS[0], GATEWAY_ADDRESS[1], GATEWAY_ADDRESS[2],
             GATEWAY_ADDRESS[3]);

    netif_set_down(&gnetif);
    netif_set_addr(&gnetif, &ipaddr, &netmask, &gw);
    netif_set_up(&gnetif);

    printf("New IP set: %s\r\n", ipaddr_ntoa(&ipaddr));
}
/* USER CODE END 2 */

/**
 * LwIP initialization function
 */
void MX_LWIP_Init(void) {
    /* IP addresses initialization */
    IP_ADDRESS[0] = cfg.ip[0];
    IP_ADDRESS[1] = cfg.ip[1];
    IP_ADDRESS[2] = cfg.ip[2];
    IP_ADDRESS[3] = cfg.ip[3];
    NETMASK_ADDRESS[0] = 255;
    NETMASK_ADDRESS[1] = 255;
    NETMASK_ADDRESS[2] = 255;
    NETMASK_ADDRESS[3] = 0;
    GATEWAY_ADDRESS[0] = cfg.ip[0];
    GATEWAY_ADDRESS[1] = cfg.ip[1];
    GATEWAY_ADDRESS[2] = cfg.ip[2];
    GATEWAY_ADDRESS[3] = 1;

    /* USER CODE BEGIN IP_ADDRESSES */
    /* USER CODE END IP_ADDRESSES */

    /* Initilialize the LwIP stack with RTOS */
    tcpip_init(NULL, NULL);

    /* IP addresses initialization without DHCP (IPv4) */
    IP4_ADDR(&ipaddr, IP_ADDRESS[0], IP_ADDRESS[1], IP_ADDRESS[2],
             IP_ADDRESS[3]);
    IP4_ADDR(&netmask, NETMASK_ADDRESS[0], NETMASK_ADDRESS[1],
             NETMASK_ADDRESS[2], NETMASK_ADDRESS[3]);
    IP4_ADDR(&gw, GATEWAY_ADDRESS[0], GATEWAY_ADDRESS[1], GATEWAY_ADDRESS[2],
             GATEWAY_ADDRESS[3]);

    /* add the network interface (IPv4/IPv6) with RTOS */
    netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init,
              &tcpip_input);

    /* Registers the default network interface */
    netif_set_default(&gnetif);

    if (netif_is_link_up(&gnetif)) {
        /* When the netif is fully configured this function must be called */
        netif_set_up(&gnetif);
    } else {
        /* When the netif link is down this function must be called */
        netif_set_down(&gnetif);
    }

    /* Set the link callback function, this function is called on change of link
     * status*/
    netif_set_link_callback(&gnetif, ethernetif_update_config);

    /* create a binary semaphore used for informing ethernetif of frame
     * reception */
    osSemaphoreDef(Netif_SEM);
    Netif_LinkSemaphore = osSemaphoreCreate(osSemaphore(Netif_SEM), 1);

    link_arg.netif = &gnetif;
    link_arg.semaphore = Netif_LinkSemaphore;
    /* Create the Ethernet link handler thread */
    /* USER CODE BEGIN OS_THREAD_DEF_CREATE_CMSIS_RTOS_V1 */
    osThreadDef(LinkThr, ethernetif_set_link, osPriorityBelowNormal, 0,
                configMINIMAL_STACK_SIZE * 2);
    osThreadCreate(osThread(LinkThr), &link_arg);
    /* USER CODE END OS_THREAD_DEF_CREATE_CMSIS_RTOS_V1 */

    /* USER CODE BEGIN 3 */

    /* USER CODE END 3 */
}

#ifdef USE_OBSOLETE_USER_CODE_SECTION_4
/* Kept to help code migration. (See new 4_1, 4_2... sections) */
/* Avoid to use this user section which will become obsolete. */
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
#endif

#if defined(__CC_ARM) /* MDK ARM Compiler */
/**
 * Opens a serial device for communication.
 *
 * @param devnum device number
 * @return handle to serial device if successful, NULL otherwise
 */
sio_fd_t sio_open(u8_t devnum) {
    sio_fd_t sd;

    /* USER CODE BEGIN 7 */
    sd = 0;  // dummy code
             /* USER CODE END 7 */

    return sd;
}

/**
 * Sends a single character to the serial device.
 *
 * @param c character to send
 * @param fd serial device handle
 *
 * @note This function will block until the character can be sent.
 */
void sio_send(u8_t c, sio_fd_t fd) {
    /* USER CODE BEGIN 8 */
    /* USER CODE END 8 */
}

/**
 * Reads from the serial device.
 *
 * @param fd serial device handle
 * @param data pointer to data buffer for receiving
 * @param len maximum length (in bytes) of data to receive
 * @return number of bytes actually received - may be 0 if aborted by
 * sio_read_abort
 *
 * @note This function will block until data can be received. The blocking
 * can be cancelled by calling sio_read_abort().
 */
u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len) {
    u32_t recved_bytes;

    /* USER CODE BEGIN 9 */
    recved_bytes = 0;  // dummy code
                       /* USER CODE END 9 */
    return recved_bytes;
}

/**
 * Tries to read from the serial device. Same as sio_read but returns
 * immediately if no data is available and never blocks.
 *
 * @param fd serial device handle
 * @param data pointer to data buffer for receiving
 * @param len maximum length (in bytes) of data to receive
 * @return number of bytes actually received
 */
u32_t sio_tryread(sio_fd_t fd, u8_t *data, u32_t len) {
    u32_t recved_bytes;

    /* USER CODE BEGIN 10 */
    recved_bytes = 0;  // dummy code
                       /* USER CODE END 10 */
    return recved_bytes;
}
#endif /* MDK ARM Compiler */
